{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.5"
    },
    "colab": {
      "name": "5-1_2_DCGAN.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MxWuvPkLLVRA"
      },
      "source": [
        "# 5.1-2 DCGANの作成\n",
        "\n",
        "- 本ファイルでは、DCGANのネットワークを実装とDCGANの学習をします。\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNzAIdHvLVRB"
      },
      "source": [
        "# 5.1 学習目標\n",
        "\n",
        "1.\tGeneratorが画像を生成するためにどのようなニューラルネットワークの構造になっているのかを理解する\n",
        "2.\tDiscriminatorが画像の識別をするためにどのようなニューラルネットワークの構造になっているのかを理解する\n",
        "3.\tGANの一般的な損失関数の形とニューラルネットワークの学習の流れを理解する\n",
        "4.\tDCGANのネットワークを実装できるようになる\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yuyxShi0LVRC"
      },
      "source": [
        "# 5.2 学習目標\n",
        "\n",
        "1.\tGANの損失関数の形を理解する\n",
        "2.\tDCGANを実装し、手書き数字画像が生成できる\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IhoMhs_hLVRC"
      },
      "source": [
        "# 事前準備\n",
        "書籍の指示に従い、本章で使用するデータを用意します"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yrUvv6xeLVRD"
      },
      "source": [
        "# パッケージのimport\n",
        "import random\n",
        "import math\n",
        "import time\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "\n",
        "import torch\n",
        "import torch.utils.data as data\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "\n",
        "from torchvision import transforms"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HlW329JeLVRG"
      },
      "source": [
        "# Setup seeds\n",
        "torch.manual_seed(1234)\n",
        "np.random.seed(1234)\n",
        "random.seed(1234)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PRMgvaTfLVRI"
      },
      "source": [
        "# 転置畳み込みの例"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JD5-ykhjLVRI",
        "outputId": "a376fa58-015e-4a61-efbd-4a9fbbc370d6"
      },
      "source": [
        "input = torch.tensor([[[[1., 1.], [2., 2.]]]])\n",
        "print(\"入力データ\")\n",
        "print(input)\n",
        "print(\"-----\")\n",
        "\n",
        "print(\"通常の畳み込み\")\n",
        "m = nn.Conv2d(1, 1, 2, stride=1, bias=False)\n",
        "m.weight.data[0, 0, 0, 0] = 1\n",
        "m.weight.data[0, 0, 0, 1] = 2\n",
        "m.weight.data[0, 0, 1, 0] = 3\n",
        "m.weight.data[0, 0, 1, 1] = 4\n",
        "print(\"カーネル\")\n",
        "print(m.weight)\n",
        "print(\"出力\")\n",
        "print(m(input))\n",
        "\n",
        "print(\"-----\")\n",
        "print(\"転置畳み込み\")\n",
        "m = nn.ConvTranspose2d(1, 1, 2, stride=1, bias=False)\n",
        "m.weight.data[0, 0, 0, 0] = 1\n",
        "m.weight.data[0, 0, 0, 1] = 2\n",
        "m.weight.data[0, 0, 1, 0] = 3\n",
        "m.weight.data[0, 0, 1, 1] = 4\n",
        "print(\"カーネル\")\n",
        "print(m.weight)\n",
        "print(\"出力\")\n",
        "print(m(input))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "入力データ\n",
            "tensor([[[[1., 1.],\n",
            "          [2., 2.]]]])\n",
            "-----\n",
            "通常の畳み込み\n",
            "カーネル\n",
            "Parameter containing:\n",
            "tensor([[[[1., 2.],\n",
            "          [3., 4.]]]], grad_fn=<CopySlices>)\n",
            "出力\n",
            "tensor([[[[17.]]]], grad_fn=<MkldnnConvolutionBackward>)\n",
            "-----\n",
            "転置畳み込み\n",
            "カーネル\n",
            "Parameter containing:\n",
            "tensor([[[[1., 2.],\n",
            "          [3., 4.]]]], grad_fn=<CopySlices>)\n",
            "出力\n",
            "tensor([[[[ 1.,  3.,  2.],\n",
            "          [ 5., 13.,  8.],\n",
            "          [ 6., 14.,  8.]]]], grad_fn=<ThnnConvTranspose2DBackward>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_M-Le4U2LVRL"
      },
      "source": [
        "# Generatorの実装"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xvTc-Z6sLVRM"
      },
      "source": [
        "class Generator(nn.Module):\n",
        "\n",
        "    def __init__(self, z_dim=20, image_size=64):\n",
        "        super(Generator, self).__init__()\n",
        "\n",
        "        self.layer1 = nn.Sequential(\n",
        "            nn.ConvTranspose2d(z_dim, image_size * 8,\n",
        "                               kernel_size=4, stride=1),\n",
        "            nn.BatchNorm2d(image_size * 8),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        self.layer2 = nn.Sequential(\n",
        "            nn.ConvTranspose2d(image_size * 8, image_size * 4,\n",
        "                               kernel_size=4, stride=2, padding=1),\n",
        "            nn.BatchNorm2d(image_size * 4),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        self.layer3 = nn.Sequential(\n",
        "            nn.ConvTranspose2d(image_size * 4, image_size * 2,\n",
        "                               kernel_size=4, stride=2, padding=1),\n",
        "            nn.BatchNorm2d(image_size * 2),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        self.layer4 = nn.Sequential(\n",
        "            nn.ConvTranspose2d(image_size * 2, image_size,\n",
        "                               kernel_size=4, stride=2, padding=1),\n",
        "            nn.BatchNorm2d(image_size),\n",
        "            nn.ReLU(inplace=True))\n",
        "\n",
        "        self.last = nn.Sequential(\n",
        "            nn.ConvTranspose2d(image_size, 1, kernel_size=4,\n",
        "                               stride=2, padding=1),\n",
        "            nn.Tanh())\n",
        "        # 注意：白黒画像なので出力チャネルは1つだけ\n",
        "\n",
        "    def forward(self, z):\n",
        "        out = self.layer1(z)\n",
        "        out = self.layer2(out)\n",
        "        out = self.layer3(out)\n",
        "        out = self.layer4(out)\n",
        "        out = self.last(out)\n",
        "\n",
        "        return out\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-erAG53_LVRO",
        "outputId": "487237b6-0492-442f-9071-39441f4accee"
      },
      "source": [
        "# 動作確認\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "G = Generator(z_dim=20, image_size=64)\n",
        "\n",
        "# 入力する乱数\n",
        "input_z = torch.randn(1, 20)\n",
        "\n",
        "# テンソルサイズを(1, 20, 1, 1)に変形\n",
        "input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "\n",
        "# 偽画像を出力\n",
        "fake_images = G(input_z)\n",
        "\n",
        "img_transformed = fake_images[0][0].detach().numpy()\n",
        "plt.imshow(img_transformed, 'gray')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jQTcc6g-LVRR"
      },
      "source": [
        "# Discriminatorの実装"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zTV5kA6CLVRR"
      },
      "source": [
        "class Discriminator(nn.Module):\n",
        "\n",
        "    def __init__(self, z_dim=20, image_size=64):\n",
        "        super(Discriminator, self).__init__()\n",
        "\n",
        "        self.layer1 = nn.Sequential(\n",
        "            nn.Conv2d(1, image_size, kernel_size=4,\n",
        "                      stride=2, padding=1),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "        # 注意：白黒画像なので入力チャネルは1つだけ\n",
        "\n",
        "        self.layer2 = nn.Sequential(\n",
        "            nn.Conv2d(image_size, image_size*2, kernel_size=4,\n",
        "                      stride=2, padding=1),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "\n",
        "        self.layer3 = nn.Sequential(\n",
        "            nn.Conv2d(image_size*2, image_size*4, kernel_size=4,\n",
        "                      stride=2, padding=1),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "\n",
        "        self.layer4 = nn.Sequential(\n",
        "            nn.Conv2d(image_size*4, image_size*8, kernel_size=4,\n",
        "                      stride=2, padding=1),\n",
        "            nn.LeakyReLU(0.1, inplace=True))\n",
        "\n",
        "        self.last = nn.Conv2d(image_size*8, 1, kernel_size=4, stride=1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = self.layer1(x)\n",
        "        out = self.layer2(out)\n",
        "        out = self.layer3(out)\n",
        "        out = self.layer4(out)\n",
        "        out = self.last(out)\n",
        "\n",
        "        return out\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vutHSP4tLVRU",
        "outputId": "be49fe63-fb90-41b6-a9af-797dfb1031cf"
      },
      "source": [
        "# 動作確認\n",
        "D = Discriminator(z_dim=20, image_size=64)\n",
        "\n",
        "# 偽画像を生成\n",
        "input_z = torch.randn(1, 20)\n",
        "input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "fake_images = G(input_z)\n",
        "\n",
        "# 偽画像をDに入力\n",
        "d_out = D(fake_images)\n",
        "\n",
        "# 出力d_outにSigmoidをかけて0から1に変換\n",
        "print(nn.Sigmoid()(d_out))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[[[0.4931]]]], grad_fn=<SigmoidBackward>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3NE3ljP3LVRW"
      },
      "source": [
        "# 6.2へ\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "09elmVc3LVRW"
      },
      "source": [
        "# GANの損失関数"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XmEJaHXlLVRX"
      },
      "source": [
        "# Dの誤差関数のイメージ実装\n",
        "# maximize log(D(x)) + log(1 - D(G(z)))\n",
        "\n",
        "\n",
        "# ※ xが未定義なので動作はエラーになります\n",
        "#---------------\n",
        "\n",
        "\n",
        "# 正解ラベルを作成\n",
        "mini_batch_size = 2\n",
        "label_real = torch.full((mini_batch_size,), 1)\n",
        "\n",
        "# 偽ラベルを作成\n",
        "label_fake = torch.full((mini_batch_size,), 0)\n",
        "\n",
        "# 誤差関数を定義\n",
        "criterion = nn.BCEWithLogitsLoss(reduction='mean')\n",
        "\n",
        "# 真の画像を判定\n",
        "d_out_real = D(x)\n",
        "\n",
        "# 偽の画像を生成して判定\n",
        "input_z = torch.randn(mini_batch_size, 20)\n",
        "input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "fake_images = G(input_z)\n",
        "d_out_fake = D(fake_images)\n",
        "\n",
        "# 誤差を計算\n",
        "d_loss_real = criterion(d_out_real.view(-1), label_real)\n",
        "d_loss_fake = criterion(d_out_fake.view(-1), label_fake)\n",
        "d_loss = d_loss_real + d_loss_fake\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QBvkbAyeLVRb"
      },
      "source": [
        "# Gの誤差関数のイメージ実装\n",
        "# maximize log(D(G(z)))\n",
        "\n",
        "\n",
        "# ※ xが未定義なので動作はエラーになります\n",
        "#---------------\n",
        "\n",
        "\n",
        "# 偽の画像を生成して判定\n",
        "input_z = torch.randn(mini_batch_size, 20)\n",
        "input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "fake_images = G(input_z)\n",
        "d_out_fake = D(fake_images)\n",
        "\n",
        "# 誤差を計算\n",
        "g_loss = criterion(d_out_fake.view(-1), label_real)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5tsKlXPTLVRe"
      },
      "source": [
        "# DataLoaderの作成"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fRx1l0CALVRe"
      },
      "source": [
        "def make_datapath_list():\n",
        "    \"\"\"学習、検証の画像データとアノテーションデータへのファイルパスリストを作成する。 \"\"\"\n",
        "\n",
        "    train_img_list = list()  # 画像ファイルパスを格納\n",
        "\n",
        "    for img_idx in range(200):\n",
        "        img_path = \"./data/img_78/img_7_\" + str(img_idx)+'.jpg'\n",
        "        train_img_list.append(img_path)\n",
        "\n",
        "        img_path = \"./data/img_78/img_8_\" + str(img_idx)+'.jpg'\n",
        "        train_img_list.append(img_path)\n",
        "\n",
        "    return train_img_list\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f9xkVFhSLVRi"
      },
      "source": [
        "class ImageTransform():\n",
        "    \"\"\"画像の前処理クラス\"\"\"\n",
        "\n",
        "    def __init__(self, mean, std):\n",
        "        self.data_transform = transforms.Compose([\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean, std)\n",
        "        ])\n",
        "\n",
        "    def __call__(self, img):\n",
        "        return self.data_transform(img)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NQBMyUMKLVRk"
      },
      "source": [
        "class GAN_Img_Dataset(data.Dataset):\n",
        "    \"\"\"画像のDatasetクラス。PyTorchのDatasetクラスを継承\"\"\"\n",
        "\n",
        "    def __init__(self, file_list, transform):\n",
        "        self.file_list = file_list\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        '''画像の枚数を返す'''\n",
        "        return len(self.file_list)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        '''前処理をした画像のTensor形式のデータを取得'''\n",
        "\n",
        "        img_path = self.file_list[index]\n",
        "        img = Image.open(img_path)  # [高さ][幅]白黒\n",
        "\n",
        "        # 画像の前処理\n",
        "        img_transformed = self.transform(img)\n",
        "\n",
        "        return img_transformed\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WNOkTVspLVRn",
        "outputId": "29984444-bf55-4a44-e273-52d669c3bebf"
      },
      "source": [
        "# DataLoaderの作成と動作確認\n",
        "\n",
        "# ファイルリストを作成\n",
        "train_img_list=make_datapath_list()\n",
        "\n",
        "# Datasetを作成\n",
        "mean = (0.5,)\n",
        "std = (0.5,)\n",
        "train_dataset = GAN_Img_Dataset(\n",
        "    file_list=train_img_list, transform=ImageTransform(mean, std))\n",
        "\n",
        "# DataLoaderを作成\n",
        "batch_size = 64\n",
        "\n",
        "train_dataloader = torch.utils.data.DataLoader(\n",
        "    train_dataset, batch_size=batch_size, shuffle=True)\n",
        "\n",
        "# 動作の確認\n",
        "batch_iterator = iter(train_dataloader)  # イテレータに変換\n",
        "imges = next(batch_iterator)  # 1番目の要素を取り出す\n",
        "print(imges.size())  # torch.Size([64, 1, 64, 64])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([64, 1, 64, 64])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c6iCFAr9LVRq"
      },
      "source": [
        "# 学習させる"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hv0vFM5OLVRr",
        "outputId": "1764d1c7-0525-43f1-fe81-d4504ed8e341"
      },
      "source": [
        "# ネットワークの初期化\n",
        "def weights_init(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        # Conv2dとConvTranspose2dの初期化\n",
        "        nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
        "        nn.init.constant_(m.bias.data, 0)\n",
        "    elif classname.find('BatchNorm') != -1:\n",
        "        # BatchNorm2dの初期化\n",
        "        nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
        "        nn.init.constant_(m.bias.data, 0)\n",
        "\n",
        "\n",
        "# 初期化の実施\n",
        "G.apply(weights_init)\n",
        "D.apply(weights_init)\n",
        "\n",
        "print(\"ネットワークの初期化完了\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ネットワークの初期化完了\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ED_O_xEJLVRt"
      },
      "source": [
        "# モデルを学習させる関数を作成\n",
        "\n",
        "\n",
        "def train_model(G, D, dataloader, num_epochs):\n",
        "\n",
        "    # GPUが使えるかを確認\n",
        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    print(\"使用デバイス：\", device)\n",
        "\n",
        "    # 最適化手法の設定\n",
        "    g_lr, d_lr = 0.0001, 0.0004\n",
        "    beta1, beta2 = 0.0, 0.9\n",
        "    g_optimizer = torch.optim.Adam(G.parameters(), g_lr, [beta1, beta2])\n",
        "    d_optimizer = torch.optim.Adam(D.parameters(), d_lr, [beta1, beta2])\n",
        "\n",
        "    # 誤差関数を定義\n",
        "    criterion = nn.BCEWithLogitsLoss(reduction='mean')\n",
        "\n",
        "    # パラメータをハードコーディング\n",
        "    z_dim = 20\n",
        "    mini_batch_size = 64\n",
        "\n",
        "    # ネットワークをGPUへ\n",
        "    G.to(device)\n",
        "    D.to(device)\n",
        "\n",
        "    G.train()  # モデルを訓練モードに\n",
        "    D.train()  # モデルを訓練モードに\n",
        "\n",
        "    # ネットワークがある程度固定であれば、高速化させる\n",
        "    torch.backends.cudnn.benchmark = True\n",
        "\n",
        "    # 画像の枚数\n",
        "    num_train_imgs = len(dataloader.dataset)\n",
        "    batch_size = dataloader.batch_size\n",
        "\n",
        "    # イテレーションカウンタをセット\n",
        "    iteration = 1\n",
        "    logs = []\n",
        "\n",
        "    # epochのループ\n",
        "    for epoch in range(num_epochs):\n",
        "\n",
        "        # 開始時刻を保存\n",
        "        t_epoch_start = time.time()\n",
        "        epoch_g_loss = 0.0  # epochの損失和\n",
        "        epoch_d_loss = 0.0  # epochの損失和\n",
        "\n",
        "        print('-------------')\n",
        "        print('Epoch {}/{}'.format(epoch, num_epochs))\n",
        "        print('-------------')\n",
        "        print('（train）')\n",
        "\n",
        "        # データローダーからminibatchずつ取り出すループ\n",
        "        for imges in dataloader:\n",
        "\n",
        "            # --------------------\n",
        "            # 1. Discriminatorの学習\n",
        "            # --------------------\n",
        "            # ミニバッチがサイズが1だと、バッチノーマライゼーションでエラーになるのでさける\n",
        "            # issue #186より不要なのでコメントアウト\n",
        "            # if imges.size()[0] == 1:\n",
        "            #     continue\n",
        "\n",
        "            # GPUが使えるならGPUにデータを送る\n",
        "            imges = imges.to(device)\n",
        "\n",
        "            # 正解ラベルと偽ラベルを作成\n",
        "            # epochの最後のイテレーションはミニバッチの数が少なくなる\n",
        "            mini_batch_size = imges.size()[0]\n",
        "            label_real = torch.full((mini_batch_size,), 1).to(device)\n",
        "            label_fake = torch.full((mini_batch_size,), 0).to(device)\n",
        "\n",
        "            # 真の画像を判定\n",
        "            d_out_real = D(imges)\n",
        "\n",
        "            # 偽の画像を生成して判定\n",
        "            input_z = torch.randn(mini_batch_size, z_dim).to(device)\n",
        "            input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "            fake_images = G(input_z)\n",
        "            d_out_fake = D(fake_images)\n",
        "\n",
        "            # 誤差を計算\n",
        "            d_loss_real = criterion(d_out_real.view(-1), label_real)\n",
        "            d_loss_fake = criterion(d_out_fake.view(-1), label_fake)\n",
        "            d_loss = d_loss_real + d_loss_fake\n",
        "\n",
        "            # バックプロパゲーション\n",
        "            g_optimizer.zero_grad()\n",
        "            d_optimizer.zero_grad()\n",
        "\n",
        "            d_loss.backward()\n",
        "            d_optimizer.step()\n",
        "\n",
        "            # --------------------\n",
        "            # 2. Generatorの学習\n",
        "            # --------------------\n",
        "            # 偽の画像を生成して判定\n",
        "            input_z = torch.randn(mini_batch_size, z_dim).to(device)\n",
        "            input_z = input_z.view(input_z.size(0), input_z.size(1), 1, 1)\n",
        "            fake_images = G(input_z)\n",
        "            d_out_fake = D(fake_images)\n",
        "\n",
        "            # 誤差を計算\n",
        "            g_loss = criterion(d_out_fake.view(-1), label_real)\n",
        "\n",
        "            # バックプロパゲーション\n",
        "            g_optimizer.zero_grad()\n",
        "            d_optimizer.zero_grad()\n",
        "            g_loss.backward()\n",
        "            g_optimizer.step()\n",
        "\n",
        "            # --------------------\n",
        "            # 3. 記録\n",
        "            # --------------------\n",
        "            epoch_d_loss += d_loss.item()\n",
        "            epoch_g_loss += g_loss.item()\n",
        "            iteration += 1\n",
        "\n",
        "        # epochのphaseごとのlossと正解率\n",
        "        t_epoch_finish = time.time()\n",
        "        print('-------------')\n",
        "        print('epoch {} || Epoch_D_Loss:{:.4f} ||Epoch_G_Loss:{:.4f}'.format(\n",
        "            epoch, epoch_d_loss/batch_size, epoch_g_loss/batch_size))\n",
        "        print('timer:  {:.4f} sec.'.format(t_epoch_finish - t_epoch_start))\n",
        "        t_epoch_start = time.time()\n",
        "\n",
        "    return G, D\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YbBe5zWOLVRw",
        "outputId": "e55eafa8-4291-410f-8e12-eb3fa14f398b"
      },
      "source": [
        "# 学習・検証を実行する\n",
        "# 6分ほどかかる\n",
        "num_epochs = 200\n",
        "G_update, D_update = train_model(\n",
        "    G, D, dataloader=train_dataloader, num_epochs=num_epochs)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "使用デバイス： cuda:0\n",
            "-------------\n",
            "Epoch 0/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 0 || Epoch_D_Loss:0.1154 ||Epoch_G_Loss:0.0765\n",
            "timer:  2.6459 sec.\n",
            "-------------\n",
            "Epoch 1/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 1 || Epoch_D_Loss:0.1300 ||Epoch_G_Loss:0.1361\n",
            "timer:  1.4897 sec.\n",
            "-------------\n",
            "Epoch 2/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 2 || Epoch_D_Loss:0.0570 ||Epoch_G_Loss:0.1472\n",
            "timer:  1.5022 sec.\n",
            "-------------\n",
            "Epoch 3/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 3 || Epoch_D_Loss:0.0114 ||Epoch_G_Loss:0.3051\n",
            "timer:  1.5032 sec.\n",
            "-------------\n",
            "Epoch 4/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 4 || Epoch_D_Loss:0.1862 ||Epoch_G_Loss:0.2787\n",
            "timer:  1.4950 sec.\n",
            "-------------\n",
            "Epoch 5/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 5 || Epoch_D_Loss:0.0170 ||Epoch_G_Loss:0.2853\n",
            "timer:  1.5015 sec.\n",
            "-------------\n",
            "Epoch 6/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 6 || Epoch_D_Loss:0.1775 ||Epoch_G_Loss:0.1950\n",
            "timer:  1.5046 sec.\n",
            "-------------\n",
            "Epoch 7/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 7 || Epoch_D_Loss:0.0287 ||Epoch_G_Loss:0.2522\n",
            "timer:  1.5053 sec.\n",
            "-------------\n",
            "Epoch 8/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 8 || Epoch_D_Loss:0.1461 ||Epoch_G_Loss:0.3045\n",
            "timer:  1.5063 sec.\n",
            "-------------\n",
            "Epoch 9/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 9 || Epoch_D_Loss:0.0920 ||Epoch_G_Loss:0.1906\n",
            "timer:  1.5097 sec.\n",
            "-------------\n",
            "Epoch 10/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 10 || Epoch_D_Loss:0.0232 ||Epoch_G_Loss:0.2535\n",
            "timer:  1.5039 sec.\n",
            "-------------\n",
            "Epoch 11/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 11 || Epoch_D_Loss:0.1320 ||Epoch_G_Loss:0.3270\n",
            "timer:  1.5079 sec.\n",
            "-------------\n",
            "Epoch 12/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 12 || Epoch_D_Loss:0.0329 ||Epoch_G_Loss:0.2123\n",
            "timer:  1.5075 sec.\n",
            "-------------\n",
            "Epoch 13/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 13 || Epoch_D_Loss:0.1249 ||Epoch_G_Loss:0.1964\n",
            "timer:  1.5042 sec.\n",
            "-------------\n",
            "Epoch 14/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 14 || Epoch_D_Loss:0.1066 ||Epoch_G_Loss:0.2268\n",
            "timer:  1.5046 sec.\n",
            "-------------\n",
            "Epoch 15/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 15 || Epoch_D_Loss:0.1063 ||Epoch_G_Loss:0.2612\n",
            "timer:  1.4990 sec.\n",
            "-------------\n",
            "Epoch 16/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 16 || Epoch_D_Loss:0.0785 ||Epoch_G_Loss:0.1955\n",
            "timer:  1.5039 sec.\n",
            "-------------\n",
            "Epoch 17/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 17 || Epoch_D_Loss:0.0921 ||Epoch_G_Loss:0.1780\n",
            "timer:  1.5033 sec.\n",
            "-------------\n",
            "Epoch 18/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 18 || Epoch_D_Loss:0.1047 ||Epoch_G_Loss:0.1854\n",
            "timer:  1.5055 sec.\n",
            "-------------\n",
            "Epoch 19/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 19 || Epoch_D_Loss:0.0924 ||Epoch_G_Loss:0.1745\n",
            "timer:  1.5046 sec.\n",
            "-------------\n",
            "Epoch 20/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 20 || Epoch_D_Loss:0.1067 ||Epoch_G_Loss:0.1796\n",
            "timer:  1.5009 sec.\n",
            "-------------\n",
            "Epoch 21/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 21 || Epoch_D_Loss:0.1839 ||Epoch_G_Loss:0.3147\n",
            "timer:  1.5032 sec.\n",
            "-------------\n",
            "Epoch 22/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 22 || Epoch_D_Loss:0.0966 ||Epoch_G_Loss:0.1584\n",
            "timer:  1.5045 sec.\n",
            "-------------\n",
            "Epoch 23/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 23 || Epoch_D_Loss:0.1145 ||Epoch_G_Loss:0.1853\n",
            "timer:  1.5076 sec.\n",
            "-------------\n",
            "Epoch 24/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 24 || Epoch_D_Loss:0.1022 ||Epoch_G_Loss:0.1289\n",
            "timer:  1.5049 sec.\n",
            "-------------\n",
            "Epoch 25/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 25 || Epoch_D_Loss:0.1339 ||Epoch_G_Loss:0.1838\n",
            "timer:  1.5078 sec.\n",
            "-------------\n",
            "Epoch 26/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 26 || Epoch_D_Loss:0.0994 ||Epoch_G_Loss:0.1924\n",
            "timer:  1.5056 sec.\n",
            "-------------\n",
            "Epoch 27/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 27 || Epoch_D_Loss:0.1338 ||Epoch_G_Loss:0.1474\n",
            "timer:  1.5035 sec.\n",
            "-------------\n",
            "Epoch 28/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 28 || Epoch_D_Loss:0.1054 ||Epoch_G_Loss:0.1514\n",
            "timer:  1.5054 sec.\n",
            "-------------\n",
            "Epoch 29/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 29 || Epoch_D_Loss:0.1077 ||Epoch_G_Loss:0.1584\n",
            "timer:  1.5062 sec.\n",
            "-------------\n",
            "Epoch 30/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 30 || Epoch_D_Loss:0.1050 ||Epoch_G_Loss:0.1559\n",
            "timer:  1.5034 sec.\n",
            "-------------\n",
            "Epoch 31/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 31 || Epoch_D_Loss:0.1189 ||Epoch_G_Loss:0.1560\n",
            "timer:  1.5082 sec.\n",
            "-------------\n",
            "Epoch 32/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 32 || Epoch_D_Loss:0.1192 ||Epoch_G_Loss:0.1688\n",
            "timer:  1.5070 sec.\n",
            "-------------\n",
            "Epoch 33/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 33 || Epoch_D_Loss:0.1088 ||Epoch_G_Loss:0.1619\n",
            "timer:  1.5077 sec.\n",
            "-------------\n",
            "Epoch 34/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 34 || Epoch_D_Loss:0.1112 ||Epoch_G_Loss:0.1366\n",
            "timer:  1.5106 sec.\n",
            "-------------\n",
            "Epoch 35/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 35 || Epoch_D_Loss:0.1144 ||Epoch_G_Loss:0.1598\n",
            "timer:  1.5093 sec.\n",
            "-------------\n",
            "Epoch 36/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 36 || Epoch_D_Loss:0.1247 ||Epoch_G_Loss:0.1504\n",
            "timer:  1.5110 sec.\n",
            "-------------\n",
            "Epoch 37/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 37 || Epoch_D_Loss:0.1012 ||Epoch_G_Loss:0.1624\n",
            "timer:  1.5190 sec.\n",
            "-------------\n",
            "Epoch 38/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 38 || Epoch_D_Loss:0.1101 ||Epoch_G_Loss:0.1352\n",
            "timer:  1.5176 sec.\n",
            "-------------\n",
            "Epoch 39/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 39 || Epoch_D_Loss:0.1197 ||Epoch_G_Loss:0.1604\n",
            "timer:  1.5253 sec.\n",
            "-------------\n",
            "Epoch 40/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 40 || Epoch_D_Loss:0.1111 ||Epoch_G_Loss:0.1430\n",
            "timer:  1.5281 sec.\n",
            "-------------\n",
            "Epoch 41/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 41 || Epoch_D_Loss:0.1188 ||Epoch_G_Loss:0.1440\n",
            "timer:  1.5294 sec.\n",
            "-------------\n",
            "Epoch 42/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 42 || Epoch_D_Loss:0.1023 ||Epoch_G_Loss:0.1561\n",
            "timer:  1.5194 sec.\n",
            "-------------\n",
            "Epoch 43/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 43 || Epoch_D_Loss:0.0995 ||Epoch_G_Loss:0.1344\n",
            "timer:  1.5183 sec.\n",
            "-------------\n",
            "Epoch 44/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 44 || Epoch_D_Loss:0.1020 ||Epoch_G_Loss:0.1529\n",
            "timer:  1.5153 sec.\n",
            "-------------\n",
            "Epoch 45/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 45 || Epoch_D_Loss:0.1185 ||Epoch_G_Loss:0.1583\n",
            "timer:  1.5172 sec.\n",
            "-------------\n",
            "Epoch 46/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 46 || Epoch_D_Loss:0.1021 ||Epoch_G_Loss:0.1479\n",
            "timer:  1.5193 sec.\n",
            "-------------\n",
            "Epoch 47/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 47 || Epoch_D_Loss:0.0919 ||Epoch_G_Loss:0.1695\n",
            "timer:  1.5148 sec.\n",
            "-------------\n",
            "Epoch 48/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 48 || Epoch_D_Loss:0.0947 ||Epoch_G_Loss:0.1574\n",
            "timer:  1.5155 sec.\n",
            "-------------\n",
            "Epoch 49/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 49 || Epoch_D_Loss:0.0969 ||Epoch_G_Loss:0.1753\n",
            "timer:  1.5185 sec.\n",
            "-------------\n",
            "Epoch 50/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 50 || Epoch_D_Loss:0.0964 ||Epoch_G_Loss:0.1661\n",
            "timer:  1.5197 sec.\n",
            "-------------\n",
            "Epoch 51/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 51 || Epoch_D_Loss:0.0900 ||Epoch_G_Loss:0.1642\n",
            "timer:  1.5220 sec.\n",
            "-------------\n",
            "Epoch 52/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 52 || Epoch_D_Loss:0.0939 ||Epoch_G_Loss:0.1869\n",
            "timer:  1.5299 sec.\n",
            "-------------\n",
            "Epoch 53/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 53 || Epoch_D_Loss:0.0920 ||Epoch_G_Loss:0.1819\n",
            "timer:  1.5312 sec.\n",
            "-------------\n",
            "Epoch 54/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 54 || Epoch_D_Loss:0.0793 ||Epoch_G_Loss:0.1782\n",
            "timer:  1.5326 sec.\n",
            "-------------\n",
            "Epoch 55/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 55 || Epoch_D_Loss:0.0986 ||Epoch_G_Loss:0.2028\n",
            "timer:  1.5222 sec.\n",
            "-------------\n",
            "Epoch 56/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 56 || Epoch_D_Loss:0.0841 ||Epoch_G_Loss:0.1916\n",
            "timer:  1.5223 sec.\n",
            "-------------\n",
            "Epoch 57/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 57 || Epoch_D_Loss:0.0754 ||Epoch_G_Loss:0.2082\n",
            "timer:  1.5186 sec.\n",
            "-------------\n",
            "Epoch 58/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 58 || Epoch_D_Loss:0.1003 ||Epoch_G_Loss:0.1643\n",
            "timer:  1.5227 sec.\n",
            "-------------\n",
            "Epoch 59/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 59 || Epoch_D_Loss:0.0861 ||Epoch_G_Loss:0.1898\n",
            "timer:  1.5256 sec.\n",
            "-------------\n",
            "Epoch 60/200\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 60 || Epoch_D_Loss:0.0816 ||Epoch_G_Loss:0.2015\n",
            "timer:  1.5231 sec.\n",
            "-------------\n",
            "Epoch 61/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 61 || Epoch_D_Loss:0.0739 ||Epoch_G_Loss:0.1976\n",
            "timer:  1.5256 sec.\n",
            "-------------\n",
            "Epoch 62/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 62 || Epoch_D_Loss:0.0757 ||Epoch_G_Loss:0.1933\n",
            "timer:  1.5366 sec.\n",
            "-------------\n",
            "Epoch 63/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 63 || Epoch_D_Loss:0.0827 ||Epoch_G_Loss:0.1969\n",
            "timer:  1.5331 sec.\n",
            "-------------\n",
            "Epoch 64/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 64 || Epoch_D_Loss:0.0875 ||Epoch_G_Loss:0.2031\n",
            "timer:  1.5245 sec.\n",
            "-------------\n",
            "Epoch 65/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 65 || Epoch_D_Loss:0.0940 ||Epoch_G_Loss:0.2365\n",
            "timer:  1.5271 sec.\n",
            "-------------\n",
            "Epoch 66/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 66 || Epoch_D_Loss:0.0820 ||Epoch_G_Loss:0.1746\n",
            "timer:  1.5263 sec.\n",
            "-------------\n",
            "Epoch 67/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 67 || Epoch_D_Loss:0.0685 ||Epoch_G_Loss:0.2199\n",
            "timer:  1.5242 sec.\n",
            "-------------\n",
            "Epoch 68/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 68 || Epoch_D_Loss:0.0870 ||Epoch_G_Loss:0.2116\n",
            "timer:  1.5218 sec.\n",
            "-------------\n",
            "Epoch 69/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 69 || Epoch_D_Loss:0.0747 ||Epoch_G_Loss:0.1903\n",
            "timer:  1.5246 sec.\n",
            "-------------\n",
            "Epoch 70/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 70 || Epoch_D_Loss:0.0848 ||Epoch_G_Loss:0.2219\n",
            "timer:  1.5351 sec.\n",
            "-------------\n",
            "Epoch 71/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 71 || Epoch_D_Loss:0.0783 ||Epoch_G_Loss:0.1844\n",
            "timer:  1.5362 sec.\n",
            "-------------\n",
            "Epoch 72/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 72 || Epoch_D_Loss:0.0856 ||Epoch_G_Loss:0.2277\n",
            "timer:  1.5342 sec.\n",
            "-------------\n",
            "Epoch 73/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 73 || Epoch_D_Loss:0.0797 ||Epoch_G_Loss:0.1918\n",
            "timer:  1.5252 sec.\n",
            "-------------\n",
            "Epoch 74/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 74 || Epoch_D_Loss:0.0838 ||Epoch_G_Loss:0.1957\n",
            "timer:  1.5256 sec.\n",
            "-------------\n",
            "Epoch 75/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 75 || Epoch_D_Loss:0.0778 ||Epoch_G_Loss:0.2080\n",
            "timer:  1.5232 sec.\n",
            "-------------\n",
            "Epoch 76/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 76 || Epoch_D_Loss:0.0843 ||Epoch_G_Loss:0.2089\n",
            "timer:  1.5214 sec.\n",
            "-------------\n",
            "Epoch 77/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 77 || Epoch_D_Loss:0.0812 ||Epoch_G_Loss:0.2109\n",
            "timer:  1.5309 sec.\n",
            "-------------\n",
            "Epoch 78/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 78 || Epoch_D_Loss:0.0969 ||Epoch_G_Loss:0.2134\n",
            "timer:  1.5258 sec.\n",
            "-------------\n",
            "Epoch 79/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 79 || Epoch_D_Loss:0.0750 ||Epoch_G_Loss:0.1947\n",
            "timer:  1.5299 sec.\n",
            "-------------\n",
            "Epoch 80/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 80 || Epoch_D_Loss:0.0708 ||Epoch_G_Loss:0.2364\n",
            "timer:  1.5299 sec.\n",
            "-------------\n",
            "Epoch 81/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 81 || Epoch_D_Loss:0.0846 ||Epoch_G_Loss:0.2128\n",
            "timer:  1.5450 sec.\n",
            "-------------\n",
            "Epoch 82/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 82 || Epoch_D_Loss:0.0704 ||Epoch_G_Loss:0.2357\n",
            "timer:  1.5481 sec.\n",
            "-------------\n",
            "Epoch 83/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 83 || Epoch_D_Loss:0.0789 ||Epoch_G_Loss:0.2256\n",
            "timer:  1.5444 sec.\n",
            "-------------\n",
            "Epoch 84/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 84 || Epoch_D_Loss:0.0760 ||Epoch_G_Loss:0.2214\n",
            "timer:  1.5323 sec.\n",
            "-------------\n",
            "Epoch 85/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 85 || Epoch_D_Loss:0.0967 ||Epoch_G_Loss:0.2177\n",
            "timer:  1.5379 sec.\n",
            "-------------\n",
            "Epoch 86/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 86 || Epoch_D_Loss:0.0626 ||Epoch_G_Loss:0.2283\n",
            "timer:  1.5427 sec.\n",
            "-------------\n",
            "Epoch 87/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 87 || Epoch_D_Loss:0.0856 ||Epoch_G_Loss:0.1996\n",
            "timer:  1.5448 sec.\n",
            "-------------\n",
            "Epoch 88/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 88 || Epoch_D_Loss:0.0672 ||Epoch_G_Loss:0.2575\n",
            "timer:  1.5404 sec.\n",
            "-------------\n",
            "Epoch 89/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 89 || Epoch_D_Loss:0.0742 ||Epoch_G_Loss:0.2112\n",
            "timer:  1.5378 sec.\n",
            "-------------\n",
            "Epoch 90/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 90 || Epoch_D_Loss:0.0767 ||Epoch_G_Loss:0.2366\n",
            "timer:  1.5310 sec.\n",
            "-------------\n",
            "Epoch 91/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 91 || Epoch_D_Loss:0.0742 ||Epoch_G_Loss:0.2131\n",
            "timer:  1.5377 sec.\n",
            "-------------\n",
            "Epoch 92/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 92 || Epoch_D_Loss:0.0647 ||Epoch_G_Loss:0.2509\n",
            "timer:  1.5390 sec.\n",
            "-------------\n",
            "Epoch 93/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 93 || Epoch_D_Loss:0.0756 ||Epoch_G_Loss:0.2126\n",
            "timer:  1.5444 sec.\n",
            "-------------\n",
            "Epoch 94/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 94 || Epoch_D_Loss:0.0770 ||Epoch_G_Loss:0.2392\n",
            "timer:  1.5454 sec.\n",
            "-------------\n",
            "Epoch 95/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 95 || Epoch_D_Loss:0.0594 ||Epoch_G_Loss:0.2244\n",
            "timer:  1.5351 sec.\n",
            "-------------\n",
            "Epoch 96/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 96 || Epoch_D_Loss:0.0856 ||Epoch_G_Loss:0.2572\n",
            "timer:  1.5302 sec.\n",
            "-------------\n",
            "Epoch 97/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 97 || Epoch_D_Loss:0.0687 ||Epoch_G_Loss:0.2450\n",
            "timer:  1.5325 sec.\n",
            "-------------\n",
            "Epoch 98/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 98 || Epoch_D_Loss:0.0780 ||Epoch_G_Loss:0.2439\n",
            "timer:  1.5314 sec.\n",
            "-------------\n",
            "Epoch 99/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 99 || Epoch_D_Loss:0.0583 ||Epoch_G_Loss:0.2432\n",
            "timer:  1.5347 sec.\n",
            "-------------\n",
            "Epoch 100/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 100 || Epoch_D_Loss:0.0835 ||Epoch_G_Loss:0.2620\n",
            "timer:  1.5362 sec.\n",
            "-------------\n",
            "Epoch 101/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 101 || Epoch_D_Loss:0.0496 ||Epoch_G_Loss:0.2583\n",
            "timer:  1.5464 sec.\n",
            "-------------\n",
            "Epoch 102/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 102 || Epoch_D_Loss:0.0779 ||Epoch_G_Loss:0.3108\n",
            "timer:  1.5368 sec.\n",
            "-------------\n",
            "Epoch 103/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 103 || Epoch_D_Loss:0.0777 ||Epoch_G_Loss:0.2228\n",
            "timer:  1.5360 sec.\n",
            "-------------\n",
            "Epoch 104/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 104 || Epoch_D_Loss:0.0590 ||Epoch_G_Loss:0.2477\n",
            "timer:  1.5306 sec.\n",
            "-------------\n",
            "Epoch 105/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 105 || Epoch_D_Loss:0.0738 ||Epoch_G_Loss:0.2519\n",
            "timer:  1.5395 sec.\n",
            "-------------\n",
            "Epoch 106/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 106 || Epoch_D_Loss:0.0786 ||Epoch_G_Loss:0.2717\n",
            "timer:  1.5331 sec.\n",
            "-------------\n",
            "Epoch 107/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 107 || Epoch_D_Loss:0.0607 ||Epoch_G_Loss:0.2055\n",
            "timer:  1.5488 sec.\n",
            "-------------\n",
            "Epoch 108/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 108 || Epoch_D_Loss:0.0767 ||Epoch_G_Loss:0.2733\n",
            "timer:  1.5430 sec.\n",
            "-------------\n",
            "Epoch 109/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 109 || Epoch_D_Loss:0.0503 ||Epoch_G_Loss:0.2872\n",
            "timer:  1.5337 sec.\n",
            "-------------\n",
            "Epoch 110/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 110 || Epoch_D_Loss:0.0586 ||Epoch_G_Loss:0.3045\n",
            "timer:  1.5312 sec.\n",
            "-------------\n",
            "Epoch 111/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 111 || Epoch_D_Loss:0.0643 ||Epoch_G_Loss:0.2572\n",
            "timer:  1.5392 sec.\n",
            "-------------\n",
            "Epoch 112/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 112 || Epoch_D_Loss:0.0765 ||Epoch_G_Loss:0.2849\n",
            "timer:  1.5321 sec.\n",
            "-------------\n",
            "Epoch 113/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 113 || Epoch_D_Loss:0.0621 ||Epoch_G_Loss:0.2833\n",
            "timer:  1.5375 sec.\n",
            "-------------\n",
            "Epoch 114/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 114 || Epoch_D_Loss:0.0558 ||Epoch_G_Loss:0.2672\n",
            "timer:  1.5486 sec.\n",
            "-------------\n",
            "Epoch 115/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 115 || Epoch_D_Loss:0.0656 ||Epoch_G_Loss:0.3014\n",
            "timer:  1.5430 sec.\n",
            "-------------\n",
            "Epoch 116/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 116 || Epoch_D_Loss:0.0607 ||Epoch_G_Loss:0.2746\n",
            "timer:  1.5443 sec.\n",
            "-------------\n",
            "Epoch 117/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 117 || Epoch_D_Loss:0.0556 ||Epoch_G_Loss:0.2464\n",
            "timer:  1.5297 sec.\n",
            "-------------\n",
            "Epoch 118/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 118 || Epoch_D_Loss:0.0673 ||Epoch_G_Loss:0.2998\n",
            "timer:  1.5343 sec.\n",
            "-------------\n",
            "Epoch 119/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 119 || Epoch_D_Loss:0.0484 ||Epoch_G_Loss:0.3512\n",
            "timer:  1.5418 sec.\n",
            "-------------\n",
            "Epoch 120/200\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 120 || Epoch_D_Loss:0.0721 ||Epoch_G_Loss:0.2344\n",
            "timer:  1.5560 sec.\n",
            "-------------\n",
            "Epoch 121/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 121 || Epoch_D_Loss:0.0636 ||Epoch_G_Loss:0.3001\n",
            "timer:  1.5445 sec.\n",
            "-------------\n",
            "Epoch 122/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 122 || Epoch_D_Loss:0.0573 ||Epoch_G_Loss:0.2712\n",
            "timer:  1.5426 sec.\n",
            "-------------\n",
            "Epoch 123/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 123 || Epoch_D_Loss:0.0645 ||Epoch_G_Loss:0.3071\n",
            "timer:  1.5289 sec.\n",
            "-------------\n",
            "Epoch 124/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 124 || Epoch_D_Loss:0.0431 ||Epoch_G_Loss:0.2718\n",
            "timer:  1.5403 sec.\n",
            "-------------\n",
            "Epoch 125/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 125 || Epoch_D_Loss:0.0863 ||Epoch_G_Loss:0.2736\n",
            "timer:  1.5383 sec.\n",
            "-------------\n",
            "Epoch 126/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 126 || Epoch_D_Loss:0.0455 ||Epoch_G_Loss:0.3053\n",
            "timer:  1.5537 sec.\n",
            "-------------\n",
            "Epoch 127/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 127 || Epoch_D_Loss:0.0700 ||Epoch_G_Loss:0.3348\n",
            "timer:  1.5524 sec.\n",
            "-------------\n",
            "Epoch 128/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 128 || Epoch_D_Loss:0.0424 ||Epoch_G_Loss:0.3200\n",
            "timer:  1.5320 sec.\n",
            "-------------\n",
            "Epoch 129/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 129 || Epoch_D_Loss:0.0506 ||Epoch_G_Loss:0.3187\n",
            "timer:  1.5353 sec.\n",
            "-------------\n",
            "Epoch 130/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 130 || Epoch_D_Loss:0.0479 ||Epoch_G_Loss:0.3213\n",
            "timer:  1.5350 sec.\n",
            "-------------\n",
            "Epoch 131/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 131 || Epoch_D_Loss:0.0567 ||Epoch_G_Loss:0.2941\n",
            "timer:  1.5384 sec.\n",
            "-------------\n",
            "Epoch 132/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 132 || Epoch_D_Loss:0.0482 ||Epoch_G_Loss:0.3068\n",
            "timer:  1.5509 sec.\n",
            "-------------\n",
            "Epoch 133/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 133 || Epoch_D_Loss:0.0517 ||Epoch_G_Loss:0.3699\n",
            "timer:  1.5433 sec.\n",
            "-------------\n",
            "Epoch 134/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 134 || Epoch_D_Loss:0.0614 ||Epoch_G_Loss:0.2563\n",
            "timer:  1.5404 sec.\n",
            "-------------\n",
            "Epoch 135/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 135 || Epoch_D_Loss:0.0521 ||Epoch_G_Loss:0.3576\n",
            "timer:  1.5364 sec.\n",
            "-------------\n",
            "Epoch 136/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 136 || Epoch_D_Loss:0.0473 ||Epoch_G_Loss:0.3172\n",
            "timer:  1.5339 sec.\n",
            "-------------\n",
            "Epoch 137/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 137 || Epoch_D_Loss:0.0644 ||Epoch_G_Loss:0.3454\n",
            "timer:  1.5324 sec.\n",
            "-------------\n",
            "Epoch 138/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 138 || Epoch_D_Loss:0.0423 ||Epoch_G_Loss:0.3290\n",
            "timer:  1.5519 sec.\n",
            "-------------\n",
            "Epoch 139/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 139 || Epoch_D_Loss:0.0330 ||Epoch_G_Loss:0.4088\n",
            "timer:  1.5474 sec.\n",
            "-------------\n",
            "Epoch 140/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 140 || Epoch_D_Loss:0.0591 ||Epoch_G_Loss:0.2931\n",
            "timer:  1.5377 sec.\n",
            "-------------\n",
            "Epoch 141/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 141 || Epoch_D_Loss:0.0455 ||Epoch_G_Loss:0.3426\n",
            "timer:  1.5307 sec.\n",
            "-------------\n",
            "Epoch 142/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 142 || Epoch_D_Loss:0.0540 ||Epoch_G_Loss:0.3292\n",
            "timer:  1.5365 sec.\n",
            "-------------\n",
            "Epoch 143/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 143 || Epoch_D_Loss:0.0451 ||Epoch_G_Loss:0.3693\n",
            "timer:  1.5298 sec.\n",
            "-------------\n",
            "Epoch 144/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 144 || Epoch_D_Loss:0.0345 ||Epoch_G_Loss:0.3466\n",
            "timer:  1.5376 sec.\n",
            "-------------\n",
            "Epoch 145/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 145 || Epoch_D_Loss:0.0513 ||Epoch_G_Loss:0.3657\n",
            "timer:  1.5451 sec.\n",
            "-------------\n",
            "Epoch 146/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 146 || Epoch_D_Loss:0.0507 ||Epoch_G_Loss:0.3329\n",
            "timer:  1.5498 sec.\n",
            "-------------\n",
            "Epoch 147/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 147 || Epoch_D_Loss:0.0309 ||Epoch_G_Loss:0.3963\n",
            "timer:  1.5479 sec.\n",
            "-------------\n",
            "Epoch 148/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 148 || Epoch_D_Loss:0.0402 ||Epoch_G_Loss:0.3642\n",
            "timer:  1.5389 sec.\n",
            "-------------\n",
            "Epoch 149/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 149 || Epoch_D_Loss:0.0578 ||Epoch_G_Loss:0.3243\n",
            "timer:  1.5414 sec.\n",
            "-------------\n",
            "Epoch 150/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 150 || Epoch_D_Loss:0.0272 ||Epoch_G_Loss:0.3856\n",
            "timer:  1.5377 sec.\n",
            "-------------\n",
            "Epoch 151/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 151 || Epoch_D_Loss:0.0465 ||Epoch_G_Loss:0.3825\n",
            "timer:  1.5569 sec.\n",
            "-------------\n",
            "Epoch 152/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 152 || Epoch_D_Loss:0.0533 ||Epoch_G_Loss:0.3773\n",
            "timer:  1.5442 sec.\n",
            "-------------\n",
            "Epoch 153/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 153 || Epoch_D_Loss:0.0225 ||Epoch_G_Loss:0.3985\n",
            "timer:  1.5362 sec.\n",
            "-------------\n",
            "Epoch 154/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 154 || Epoch_D_Loss:0.0682 ||Epoch_G_Loss:0.3559\n",
            "timer:  1.5340 sec.\n",
            "-------------\n",
            "Epoch 155/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 155 || Epoch_D_Loss:0.0235 ||Epoch_G_Loss:0.4128\n",
            "timer:  1.5408 sec.\n",
            "-------------\n",
            "Epoch 156/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 156 || Epoch_D_Loss:0.0512 ||Epoch_G_Loss:0.3749\n",
            "timer:  1.5340 sec.\n",
            "-------------\n",
            "Epoch 157/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 157 || Epoch_D_Loss:0.0318 ||Epoch_G_Loss:0.4339\n",
            "timer:  1.5380 sec.\n",
            "-------------\n",
            "Epoch 158/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 158 || Epoch_D_Loss:0.0346 ||Epoch_G_Loss:0.4053\n",
            "timer:  1.5520 sec.\n",
            "-------------\n",
            "Epoch 159/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 159 || Epoch_D_Loss:0.0588 ||Epoch_G_Loss:0.4002\n",
            "timer:  1.5414 sec.\n",
            "-------------\n",
            "Epoch 160/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 160 || Epoch_D_Loss:0.0427 ||Epoch_G_Loss:0.3889\n",
            "timer:  1.5347 sec.\n",
            "-------------\n",
            "Epoch 161/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 161 || Epoch_D_Loss:0.0262 ||Epoch_G_Loss:0.4006\n",
            "timer:  1.5331 sec.\n",
            "-------------\n",
            "Epoch 162/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 162 || Epoch_D_Loss:0.0289 ||Epoch_G_Loss:0.4516\n",
            "timer:  1.5409 sec.\n",
            "-------------\n",
            "Epoch 163/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 163 || Epoch_D_Loss:0.0471 ||Epoch_G_Loss:0.3547\n",
            "timer:  1.5320 sec.\n",
            "-------------\n",
            "Epoch 164/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 164 || Epoch_D_Loss:0.0347 ||Epoch_G_Loss:0.4512\n",
            "timer:  1.5469 sec.\n",
            "-------------\n",
            "Epoch 165/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 165 || Epoch_D_Loss:0.0451 ||Epoch_G_Loss:0.3603\n",
            "timer:  1.5357 sec.\n",
            "-------------\n",
            "Epoch 166/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 166 || Epoch_D_Loss:0.0327 ||Epoch_G_Loss:0.4453\n",
            "timer:  1.5384 sec.\n",
            "-------------\n",
            "Epoch 167/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 167 || Epoch_D_Loss:0.0437 ||Epoch_G_Loss:0.3902\n",
            "timer:  1.5341 sec.\n",
            "-------------\n",
            "Epoch 168/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 168 || Epoch_D_Loss:0.0452 ||Epoch_G_Loss:0.4044\n",
            "timer:  1.5398 sec.\n",
            "-------------\n",
            "Epoch 169/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 169 || Epoch_D_Loss:0.0233 ||Epoch_G_Loss:0.4274\n",
            "timer:  1.5342 sec.\n",
            "-------------\n",
            "Epoch 170/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 170 || Epoch_D_Loss:0.0356 ||Epoch_G_Loss:0.4588\n",
            "timer:  1.5453 sec.\n",
            "-------------\n",
            "Epoch 171/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 171 || Epoch_D_Loss:0.0281 ||Epoch_G_Loss:0.4104\n",
            "timer:  1.5483 sec.\n",
            "-------------\n",
            "Epoch 172/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 172 || Epoch_D_Loss:0.0319 ||Epoch_G_Loss:0.4752\n",
            "timer:  1.5444 sec.\n",
            "-------------\n",
            "Epoch 173/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 173 || Epoch_D_Loss:0.0409 ||Epoch_G_Loss:0.4312\n",
            "timer:  1.5366 sec.\n",
            "-------------\n",
            "Epoch 174/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 174 || Epoch_D_Loss:0.0361 ||Epoch_G_Loss:0.4490\n",
            "timer:  1.5343 sec.\n",
            "-------------\n",
            "Epoch 175/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 175 || Epoch_D_Loss:0.0386 ||Epoch_G_Loss:0.4231\n",
            "timer:  1.5397 sec.\n",
            "-------------\n",
            "Epoch 176/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 176 || Epoch_D_Loss:0.0283 ||Epoch_G_Loss:0.4874\n",
            "timer:  1.5398 sec.\n",
            "-------------\n",
            "Epoch 177/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 177 || Epoch_D_Loss:0.0386 ||Epoch_G_Loss:0.4104\n",
            "timer:  1.5507 sec.\n",
            "-------------\n",
            "Epoch 178/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 178 || Epoch_D_Loss:0.0363 ||Epoch_G_Loss:0.4207\n",
            "timer:  1.5455 sec.\n",
            "-------------\n",
            "Epoch 179/200\n",
            "-------------\n",
            "（train）\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "-------------\n",
            "epoch 179 || Epoch_D_Loss:0.0249 ||Epoch_G_Loss:0.4146\n",
            "timer:  1.5375 sec.\n",
            "-------------\n",
            "Epoch 180/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 180 || Epoch_D_Loss:0.0480 ||Epoch_G_Loss:0.4015\n",
            "timer:  1.5364 sec.\n",
            "-------------\n",
            "Epoch 181/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 181 || Epoch_D_Loss:0.0259 ||Epoch_G_Loss:0.4990\n",
            "timer:  1.5421 sec.\n",
            "-------------\n",
            "Epoch 182/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 182 || Epoch_D_Loss:0.0129 ||Epoch_G_Loss:0.5540\n",
            "timer:  1.5535 sec.\n",
            "-------------\n",
            "Epoch 183/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 183 || Epoch_D_Loss:0.0723 ||Epoch_G_Loss:0.2949\n",
            "timer:  1.5466 sec.\n",
            "-------------\n",
            "Epoch 184/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 184 || Epoch_D_Loss:0.0142 ||Epoch_G_Loss:0.4174\n",
            "timer:  1.5371 sec.\n",
            "-------------\n",
            "Epoch 185/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 185 || Epoch_D_Loss:0.0494 ||Epoch_G_Loss:0.4414\n",
            "timer:  1.5362 sec.\n",
            "-------------\n",
            "Epoch 186/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 186 || Epoch_D_Loss:0.0132 ||Epoch_G_Loss:0.4922\n",
            "timer:  1.5400 sec.\n",
            "-------------\n",
            "Epoch 187/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 187 || Epoch_D_Loss:0.0399 ||Epoch_G_Loss:0.4714\n",
            "timer:  1.5400 sec.\n",
            "-------------\n",
            "Epoch 188/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 188 || Epoch_D_Loss:0.0109 ||Epoch_G_Loss:0.5377\n",
            "timer:  1.5341 sec.\n",
            "-------------\n",
            "Epoch 189/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 189 || Epoch_D_Loss:0.0493 ||Epoch_G_Loss:0.4879\n",
            "timer:  1.5495 sec.\n",
            "-------------\n",
            "Epoch 190/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 190 || Epoch_D_Loss:0.0137 ||Epoch_G_Loss:0.5246\n",
            "timer:  1.5444 sec.\n",
            "-------------\n",
            "Epoch 191/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 191 || Epoch_D_Loss:0.0475 ||Epoch_G_Loss:0.4492\n",
            "timer:  1.5365 sec.\n",
            "-------------\n",
            "Epoch 192/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 192 || Epoch_D_Loss:0.0139 ||Epoch_G_Loss:0.4902\n",
            "timer:  1.5372 sec.\n",
            "-------------\n",
            "Epoch 193/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 193 || Epoch_D_Loss:0.0523 ||Epoch_G_Loss:0.4440\n",
            "timer:  1.5417 sec.\n",
            "-------------\n",
            "Epoch 194/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 194 || Epoch_D_Loss:0.0153 ||Epoch_G_Loss:0.4942\n",
            "timer:  1.5465 sec.\n",
            "-------------\n",
            "Epoch 195/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 195 || Epoch_D_Loss:0.0236 ||Epoch_G_Loss:0.5123\n",
            "timer:  1.5463 sec.\n",
            "-------------\n",
            "Epoch 196/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 196 || Epoch_D_Loss:0.0345 ||Epoch_G_Loss:0.5144\n",
            "timer:  1.5397 sec.\n",
            "-------------\n",
            "Epoch 197/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 197 || Epoch_D_Loss:0.0128 ||Epoch_G_Loss:0.6205\n",
            "timer:  1.5328 sec.\n",
            "-------------\n",
            "Epoch 198/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 198 || Epoch_D_Loss:0.0596 ||Epoch_G_Loss:0.3435\n",
            "timer:  1.5351 sec.\n",
            "-------------\n",
            "Epoch 199/200\n",
            "-------------\n",
            "（train）\n",
            "-------------\n",
            "epoch 199 || Epoch_D_Loss:0.0111 ||Epoch_G_Loss:0.4605\n",
            "timer:  1.5356 sec.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qCbGU5sHLVRz",
        "outputId": "6fee201e-0304-405e-ee71-4fa5678b1105"
      },
      "source": [
        "# 生成画像と訓練データを可視化する\n",
        "# 本セルは良い感じの画像が生成されるまで、何度も実行し直しています。\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "# 入力の乱数生成\n",
        "batch_size = 8\n",
        "z_dim = 20\n",
        "fixed_z = torch.randn(batch_size, z_dim)\n",
        "fixed_z = fixed_z.view(fixed_z.size(0), fixed_z.size(1), 1, 1)\n",
        "\n",
        "# 画像生成\n",
        "G_update.eval()\n",
        "fake_images = G_update(fixed_z.to(device))\n",
        "\n",
        "# 訓練データ\n",
        "batch_iterator = iter(train_dataloader)  # イテレータに変換\n",
        "imges = next(batch_iterator)  # 1番目の要素を取り出す\n",
        "\n",
        "\n",
        "# 出力\n",
        "fig = plt.figure(figsize=(15, 6))\n",
        "for i in range(0, 5):\n",
        "    # 上段に訓練データを\n",
        "    plt.subplot(2, 5, i+1)\n",
        "    plt.imshow(imges[i][0].cpu().detach().numpy(), 'gray')\n",
        "\n",
        "    # 下段に生成データを表示する\n",
        "    plt.subplot(2, 5, 5+i+1)\n",
        "    plt.imshow(fake_images[i][0].cpu().detach().numpy(), 'gray')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x432 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fvVWDdkMLVR1"
      },
      "source": [
        "以上"
      ]
    }
  ]
}